#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
using namespace std;

//#pragma pack(1)
//
//struct A
//{
//private:
//	int _a;
//	char _i;
//};
//
//struct B
//{
//private:
//	char _i;
//	int _a;
//};
//
//int main()
//{
//	cout << sizeof(A) << endl;
//	cout << sizeof(B) << endl;
//	char i = 1;
//	int j = 10;
//
//	return 0;
//}

//class Date
//{
//public:
//	void Init(int year, int month, int day)
//	{
//		this->_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	// const Date* const p;
//	/*void Print(Date* const this)
//	{
//		cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
//	}*/
//	
//	// 特点：
//	// 1、形参和实参的位置，我们不能显示写
//	// 2、函数内部可以使用
//	void Print()
//	{
//		//this = nullptr;
//		cout << this->_year << "-" << this->_month << "-" << _day << endl;
//	}
//	
//private:
//	// 声明
//	int _year; // 年
//	int _month; // 月
//	int _day; // 日
//};

//int main()
//{
//	Date d1;
//	d1.Init(2024, 1, 27);
//
//	Date d2;
//	d2.Init(2024, 2, 28);
//
//	//d1.Print(&d1);
//	//d2.Print(&d2);
//
//	d1.Print();
//	d2.Print();
//
//	return 0;
//}

// this 存在哪里  b 因为他是一个形参（有些编译比如vs可能会用寄存器存储）
// a、堆   b、栈   c、静态区   d、常量区  e、对象里面
//int main()
//{
//	Date d1;
//	d1.Init(2024, 1, 27);
//
//	Date d2;
//	d2.Init(2024, 2, 28);
//
//	const int i = 0;
//	int j = 1;
//	const char* p = "xzxxxxxx";
//	cout << &i << endl;
//	cout << &j << endl;
//	cout << &p << endl;
//	cout << (void*)p << endl;
//
//	return 0;
//}


// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
//class A
//{
//public:
//	void PrintA()
//	{
//		cout << this << endl;
//		//cout << _a << endl;
//		cout << "Print()" << endl;
//	}
//private:
//	int _a;
//};
//
//int main()
//{
//	A* p = nullptr;
//
//	p->PrintA();
//	(*p).PrintA();
//
//	return 0;
//}
//

//class Date
//{
//public:
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1;
//	// 有时候容易忘记
//	d1.Init(2024, 1, 27);
//
//	return 0;
//}

// 特殊的成员函数
//class Date
//{
//public:
//	//Date()
//	//{
//	//	_year = 1;
//	//	_month = 1;
//	//	_day = 1;
//	//}
//	
//	/*
//	Date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}*/
//
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	//Date func();
//
//	//Date d1();
//	Date d1;
//	d1.Print();
//
//	Date d2(2024, 1, 27);
//	d2.Print();
//
//	Date d3(2024);
//	d3.Print();
//
//	return 0;
//}

//class A
//{
//public:
//	A()
//	{
//		cout << "A()" << endl;
//		_a = 0;
//	}
//private:
//	int _a;
//};
//
//class Date
//{
//public:
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
//private:
//	// 声明给缺省值
//	int _year = 1;
//	int _month = 1;
//	int _day;
//
//	A _aa;
//};
//
//// 内置类型/基本类型   int/char/double/指针  语言自己自身定义的类型
//// 自定义类型          struct/class
//// 
//// 构造函数：默认成员函数，我们不写编译器会生成一个
//// 默认生成的构造函数，对于内置类型不做处理，自定义类型回去调用他的默认构造
//// 如果我们没写任何一个构造函数，编译器才会自动生成的，如果我们写了就不会生成了
//
//// C++11 委员会对这个语法进行打补丁, 在声明的位置给缺省值
//
//// 分析一个类型成员和初始化需求
//// 需要写构造函数我们就自己写；不需要时就用编译器自己生成的
//// 结论：绝大多数场景下面都需要自己实现构造函数
//class Stack
//{
//public:
//	Stack()
//	{
//		//...
//		cout << "Stack()" << endl;
//	}
//	//...
//};
//
//// 两个栈实现队列
//class MyQueue
//{
//private:
//	Stack st1;
//	Stack st2;
//};
//
//int main()
//{
//	Date d1;
//	d1.Print();
//
//	MyQueue q;
//
//	return 0;
//}

class Date
{
public:
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}

	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

	~Date()
	{
		cout << this << endl;
		cout << "~Date()" << endl;
	}

private:
	// 声明给缺省值
	int _year = 1;
	int _month = 1;
	int _day;
};

void func()
{
	Date d2;
}

class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		_array = (int*)malloc(sizeof(int) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}

	void Push(int data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	bool Empty()
	{
		return _size == 0;
	}

	int Top()
	{
		return _array[_size - 1];
	}

	void Pop()
	{
		//..
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
		if (_array)
		{
			free(_array);
			_array = nullptr;
		}

		_size = _capacity = 0;
	}

private:
	int* _array;
	int _capacity;
	int _size;
};

// 默认生成的析构函数跟构造函数类似
// 内置类型不做处理，自定义类型的成员去调用他的析构
class MyQueue
{
private:
	Stack _st1;
	Stack _st2;
};

bool isValid(const char* s) {
	Stack st;

	while (*s)
	{
		if (*s == '(' || *s == '[' || *s == '{')
		{
			st.Push(*s);
		}
		else
		{
			if (st.Empty())
			{
				return false;
			}
			char topVal = st.Top();
			st.Pop();
			if ((*s == ']' && topVal != '[')
				|| (*s == ')' && topVal != '(')
				|| (*s == '}' && topVal != '{'))
			{
				return false;
			}
		}

		++s;
	}

	return st.Empty();
}

int main()
{
	/*func();

	Date d1;
	d1.Print();

	Stack st1;*/

	//isValid("()[]{}");

	MyQueue q;

	return 0;
}